Previous: Expression Section, Up: Expressions

#### 3.10.9 Builtin Functions

The linker script language includes a number of builtin functions for use in linker script expressions.

`ABSOLUTE(`exp`)`
  Return the absolute (non-relocatable, as opposed to non-negative) value of the expression exp. Primarily useful to assign an absolute value to a symbol within a section definition, where symbol values are normally section relative. See Expression Section.
`ADDR(`section`)`
  Return the address (VMA) of the named section. Your script must previously have defined the location of that section. In the following example, `start_of_output_1`, `symbol_1` and `symbol_2` are assigned equivalent values, except that `symbol_1` will be relative to the `.output1` section while the other two will be absolute:

                SECTIONS { ...
                  .output1 :
                    {
                    start_of_output_1 = ABSOLUTE(.);
                    ...
                    }
                  .output :
                    {
                    symbol_1 = ADDR(.output1);
                    symbol_2 = start_of_output_1;
                    }
                ... }

`ALIGN(`align`)`
`ALIGN(`exp`,`align`)`
  Return the location counter (`.`) or arbitrary expression aligned to the next align boundary. The single operand `ALIGN` doesn't change the value of the location counter—it just does arithmetic on it. The two operand `ALIGN` allows an arbitrary expression to be aligned upwards (`ALIGN(`align`)` is equivalent to `ALIGN(.,` align`)`).

  Here is an example which aligns the output `.data` section to the next `0x2000` byte boundary after the preceding section and sets a variable within the section to the next `0x8000` boundary after the input sections:

                SECTIONS { ...
                  .data ALIGN(0x2000): {
                    *(.data)
                    variable = ALIGN(0x8000);
                  }
                ... }

  The first use of `ALIGN` in this example specifies the location of a section because it is used as the optional address attribute of a section definition (see Output Section Address). The second use of `ALIGN` is used to defines the value of a symbol.

  The builtin function `NEXT` is closely related to `ALIGN`.

`ALIGNOF(`section`)`
  Return the alignment in bytes of the named section, if that section has been allocated. If the section has not been allocated when this is evaluated, the linker will report an error. In the following example, the alignment of the `.output` section is stored as the first value in that section.

                SECTIONS{ ...
                  .output {
                    LONG (ALIGNOF (.output))
                    ...
                    }
                ... }

`BLOCK(`exp`)`
  This is a synonym for `ALIGN`, for compatibility with older linker scripts. It is most often seen when setting the address of an output section.
`DATA_SEGMENT_ALIGN(`maxpagesize`,` commonpagesize`)`
  This is equivalent to either

                (ALIGN(maxpagesize) + (. & (maxpagesize - 1)))

  or

                (ALIGN(maxpagesize) + (. & (maxpagesize - commonpagesize)))

  depending on whether the latter uses fewer commonpagesize sized pages for the data segment (area between the result of this expression and `DATA_SEGMENT_END`) than the former or not. If the latter form is used, it means commonpagesize bytes of runtime memory will be saved at the expense of up to commonpagesize wasted bytes in the on-disk file.

  This expression can only be used directly in `SECTIONS` commands, not in any output section descriptions and only once in the linker script. commonpagesize should be less or equal to maxpagesize and should be the system page size the object wants to be optimized for (while still working on system page sizes up to maxpagesize).

  Example:

                  . = DATA_SEGMENT_ALIGN(0x10000, 0x2000);

`DATA_SEGMENT_END(`exp`)`
  This defines the end of data segment for `DATA_SEGMENT_ALIGN` evaluation purposes.

                  . = DATA_SEGMENT_END(.);

`DATA_SEGMENT_RELRO_END(`offset`,` exp`)`
  This defines the end of the `PT_GNU_RELRO` segment when ‘`-z relro`’ option is used. Second argument is returned. When ‘`-z relro`’ option is not present, `DATA_SEGMENT_RELRO_END` does nothing, otherwise `DATA_SEGMENT_ALIGN` is padded so that exp + offset is aligned to the most commonly used page boundary for particular target. If present in the linker script, it must always come in between `DATA_SEGMENT_ALIGN` and `DATA_SEGMENT_END`.

                  . = DATA_SEGMENT_RELRO_END(24, .);

`DEFINED(`symbol`)`
  Return 1 if symbol is in the linker global symbol table and is defined before the statement using DEFINED in the script, otherwise return 0. You can use this function to provide default values for symbols. For example, the following script fragment shows how to set a global symbol ‘`begin`’ to the first location in the ‘`.text`’ section—but if a symbol called ‘`begin`’ already existed, its value is preserved:

                SECTIONS { ...
                  .text : {
                    begin = DEFINED(begin) ? begin : . ;
                    ...
                  }
                  ...
                }

`LENGTH(`memory`)`
  Return the length of the memory region named memory.
`LOADADDR(`section`)`
  Return the absolute LMA of the named section. (see Output Section LMA).

`MAX(`exp1`,` exp2`)`
  Returns the maximum of exp1 and exp2.

`MIN(`exp1`,` exp2`)`
  Returns the minimum of exp1 and exp2.
`NEXT(`exp`)`
  Return the next unallocated address that is a multiple of exp. This function is closely related to `ALIGN(`exp`)`; unless you use the `MEMORY` command to define discontinuous memory for the output file, the two functions are equivalent.
`ORIGIN(`memory`)`
  Return the origin of the memory region named memory.
`SEGMENT_START(`segment`,` default`)`
  Return the base address of the named segment. If an explicit value has been given for this segment (with a command-line ‘`-T`’ option) that value will be returned; otherwise the value will be default. At present, the ‘`-T`’ command-line option can only be used to set the base address for the “text”, “data”, and “bss” sections, but you can use `SEGMENT_START` with any segment name.
`SIZEOF(`section`)`
  Return the size in bytes of the named section, if that section has been allocated. If the section has not been allocated when this is evaluated, the linker will report an error. In the following example, `symbol_1` and `symbol_2` are assigned identical values:

                SECTIONS{ ...
                  .output {
                    .start = . ;
                    ...
                    .end = . ;
                    }
                  symbol_1 = .end - .start ;
                  symbol_2 = SIZEOF(.output);
                ... }

`SIZEOF_HEADERS`
`sizeof_headers`
  Return the size in bytes of the output file's headers. This is information which appears at the start of the output file. You can use this number when setting the start address of the first section, if you choose, to facilitate paging.

  When producing an ELF output file, if the linker script uses the `SIZEOF_HEADERS` builtin function, the linker must compute the number of program headers before it has determined all the section addresses and sizes. If the linker later discovers that it needs additional program headers, it will report an error ‘`not enough room for program headers`’. To avoid this error, you must avoid using the `SIZEOF_HEADERS` function, or you must rework your linker script to avoid forcing the linker to use additional program headers, or you must define the program headers yourself using the `PHDRS` command (see PHDRS).